﻿
#include<iostream>
using namespace std;
//int main()
//{
//	/*编译器优化*/
//	//// i是常量表达式
//	//volatile const int i = 0;
//	////const int i = 0;  // 常量表达式
//	//cout << i << endl;
//	////int* ptr = (int*)&i;
//	//int* ptr = const_cast<int*>(&i);
//	//*ptr += 1;
//	//cout << i << endl;
//
//	//int j = 0;                         
//	//const int k = j;  // 不是常量表达式
//	//cout << k << endl;
//	//ptr = const_cast<int*>(&k);
//	//*ptr += 1;
//	//cout << k << endl;
//
//	/*数组诊断常量表达式*/
//	/*const int b = 1;
//	int a[b];
//	int i = 1;
//	const int m = i;
//
//	int k[m];*/
//
//	
//	/*cosntexpr测试*/
// //   const int d = 2;
// //   const  int  p2 = d;
//
//	//constexpr const int p3 = p2;//等价于 
//
//	// const int*  p = (int *)0x12121212;
//
//	// constexpr const int* p3 = p;
//
//
//	//const int  d = 2;
//	//const  int const * p2 = &d;
//
//	//constexpr const int * p3 = p2;//相当于非常量的const int* const p3 = &d;
//	
//
//
//	 
//	return 0;
//}


/*C++14支持了stl的array*/

//#include <iostream>
//#include <array>
//
//constexpr std::array<int, 3> createArray() {
//    std::array<int, 3> arr = { 1, 2, 3 };  // 返回std::array
//    arr[1]=1;
//    return arr;
//}
//
//int main() {
//    constexpr auto myArray = createArray();
//
//    for (auto element : myArray) {
//        std::cout << element << " ";
//    }
//    std::cout << std::endl;
//    return 0;
//}


/*if constexpr测试*/
//template <typename T>
//auto get_value(T t) {
//	if constexpr (std::is_pointer_v<T>) {
//		return *t; // 仅当T为指针类型时实例化
//	}
//	else {
//		return t; // ⾮指针类型时实例化
//	}
//}
//// 使⽤⽰例
//int main() {
//	int x = 42;
//	auto v1 = get_value(x); // 返回x本⾝
//	auto v2 = get_value(&x); // 解引⽤返回42
//}


/*constexpr修饰lamda*/
//int main()
//{
//	// constexpr lambda⽰例
//	constexpr int n = 10;
//	int y = 0;
//	constexpr auto square = [n](int x) constexpr { return x * x * n; };
//	constexpr int result = square(5); // 编译期计算：250
//	return 0;
//}


/*union 支持的constexpr*/

//constexpr union Data {
//	int i;
//	float f;
//	constexpr Data(int val) : i(val) {} // 初始化整数成员
//	constexpr Data(float val) : f(val) {} // 初始化浮点成员
//};
//int main()
//{
//	constexpr Data d1(42); // 活跃成员是i
//	
//		constexpr Data d2(3.14f); // 活跃成员是f
//	//constexpr float temp = d1.f; // 错误：访问⾮活跃成员（编译失败）
//	constexpr int temp = d1.i;
//}


/*虚函数支持的constexpr*/


//class Base {
//public:
//	constexpr Base(){}
//	virtual constexpr int value() const { return 1; }
//};
//class Derived : public Base {
//public:
//	constexpr Derived() {}
//	constexpr int value() const override { return 2; }
//};
//constexpr int get_value(const Base& b) {
//	return b.value(); // 编译期多态调⽤
//} 
//int main() {
//	constexpr int ret1 = get_value(Base());
//	constexpr int ret2 = get_value(Derived());
//	return 0;
//}


/*auto推导*/
//int i = 1;
//int* const p1 = &i; // 顶层const
//const int*  p2 = &i;
//
//// auto r2 = p1;//int*
//const auto r2 = p1;// int * const
////r2++;
//
//auto r3 = p2; // r3类型为const int*，保留底层const
// (*r3)++;
//
// const int ci = 20;
// const int& ri1 = ci; // 底层const
// auto r4 = ri1;//是int类型


/*auto万能引用*/

// 万能引⽤

//int x = 1;
//const int  cx = 2;
//auto&& rx5 = x; // int&
//auto&& rx6 = cx; // const int&
//auto&& rx7 = move(x); // int&&
////rx7++;
//auto&& rx8 = move(cx); // const int&&
//
//void func(int& x)
//{
//	cout << "void func(int& x)" << endl;
//} 
//void func(int&& x)
//{
//	cout << "void func(int&& x)" << endl;
//} 
//void func(const int& x)
//{
//	cout << "void func(const int& x)" << endl;
//}
//void func(const int&& x)
//{
//	cout << "void func(const int&& x)" << endl;
//}
//
//int main()
//{   
//	func(rx7);
//	func(rx8);
//
//	func(forward<int>(rx7));
//	func(forward<const int>(rx8));
//}


/*尾置类型自动推导*/
//#include<map>
//#include<vector>
//// 1. 复杂返回类型
//auto getComplexType() -> std::map<std::string, std::vector<int>> {
//	// ...
//}
//// 2. 依赖参数类型的返回类型
//template <typename T, typename U>
//auto add(T t, U u) -> decltype(t + u) {
//	return t + u;
//} 
//// 3. lambda表达式
//auto lambda = [](int x) -> double { return x * 1.5; };

//
//#include<typeinfo>
//#include<string>
//int main() {
//	int a = 1;
//string s= typeid(a).name();
//
//}


//using:


//template<class Val>
//using Map = map<string, Val>;
//typedef  map<string, Val> mp <Val>;
//
//int main(){
//   
//
//	Map<int> mp;//等价于map<string, int>;
//
//	return 0;
//
//}


/*static_assert*/

//template<typename T>
//void process(T value) {
//	static_assert(std::is_integral<T>::value, "T must be an integral type");
//	// 函数实现...
//}
//int main() {
//
//	//process("1");
//
//	constexpr const int buffer_size = 1;
//
//	static_assert(buffer_size > 0, "Buffer size must be positive");
//
//		return 0;
//}


/*tuple*/

//#include<tuple>
//#include<string>
//#include<typeinfo>
//int main() {
//
//
//	std::tuple<int, char, std::string> t1(1, '1', "1");
//	std::tuple<int, char, std::string> t2(2, '2', "2");
//	//std::tuple t2(2, '2', "2"); //C++17支持自动推导类型
//	t1.swap(t2);
//	//std::swap(t1, t2);
//
//	std::get<1>(t1) = '8';
//	std::cout<<std::get<1>(t1)<<"， 类型： " <<typeid(std::get<1>(t1)).name()<< std::endl;
//
//	//int x; double y;
//	//std::string z;
//	//// 使⽤std::tie解包
//	//std::tie(x, y, z) = t1;
//	//// C++17结构化绑定
//	//auto [a, b, c] = t1;
//
//}


/*tuple原理*/
//#include<tuple>
//#include<string>
//#include<typeinfo>
//
//template<typename...>
//class Tuple {};
//
//// 递归特化
//template<typename Head, typename... Tail>
//class Tuple<Head, Tail...> : private Tuple<Tail...> {
//public:
//    Head value;
//
//    // 构造函数
//    Tuple(const Head& head, const Tail&... tail)
//        : Tuple<Tail...>(tail...), value(head) {}
//
//    // 获取元素
//    template<size_t I>
//    auto& get() {
//        if constexpr (I == 0) {
//            return value;
//        } else {
//            return Tuple<Tail...>::template get<I-1>();
//        }
//    }
//};
//
//
//int main() {
//
// Tuple<int, char, std::string> t1(1, '1', "1");
// 	std::cout<<t1.get<1>()<<"， 类型： " <<typeid(t1.get<1>()).name()<< std::endl;
//
//}


/*模版元编程简单例子（递归式+模版特化）*/

//#include<iostream>
//
//template <unsigned int N>
//struct Factorial {
//	static const unsigned int value = N * Factorial<N - 1>::value;
//};
//// 终⽌条件特化
//template <>
//struct Factorial<0> {
//	static const unsigned int value = 1;
//};
//int main()
//{
//	constexpr unsigned int fact5 = Factorial<5>::value; // 编译时计算出120
//	return 0;
//}

/*去除const与移除指针的模版*/
//namespace test {
//	// 移除 const
//	// 主模板，默认情况下不改变类型
//	template <typename T>
//	struct remove_const {
//		using type = T;
//	};
//	// 针对 const T 的特化版本，移除 const
//	template <typename T>
//	struct remove_const<const T> {
//		using type = T;
//	};
//
//
//	// 移除 指针
//	template <typename T>
//	struct remove_pointer {
//		using type = T;
//	};
//	template <typename T>
//	struct remove_pointer<T*> {
//		using type = T;
//	};
//	template <typename T>
//	struct remove_pointer<T* const> {
//		using type = T;
//	};
//
//}

//判断是否为某个类型与是否两个类型相同

//namespace test {
//	// 主模板
//	template<typename T>
//	struct is_pointer {
//		static constexpr bool value = false;
//	};
//	// 针对指针类型的偏特化
//	template<typename T>
//	struct is_pointer<T*> {
//		static constexpr bool value = true;
//	};
//	// 主模板，默认情况类型不同
//	template<typename T, typename U>
//	struct is_same {
//		static constexpr bool value = false;
//	};
//	// 特化版本，当两个类型相同时
//	template<typename T>
//	struct is_same<T, T> {
//		static constexpr bool value = true;
//	};
//
//
//}


/*简单类型萃取*/
//namespace t1 {
//
//	template <typename T>
//	struct Type {
//		using type = T;
//	};
//	template <typename T>
//	struct Type<T*> {
//		using type = T*;
//	};
//	template < >
//	struct Type <int> {
//		using type = int;
//	};
//
//	template < >
//	struct Type <float> {
//		using type = float;
//	};
//
//}

/*类型萃取*/
//#include <type_traits>
//#include<iostream>
//// 1、基础类型检查
//std::is_void<void>::value; // true
//std::is_integral<int>::value; // true
//std::is_floating_point<float>::value; // true
//std::is_pointer<int*>::value; // true
//std::is_reference<int&>::value; // true
//std::is_const<const int>::value; // true
//// 2、复合类型检查
//std::is_function<void()>::value; // true
//std::is_member_object_pointer<int(Foo::*)>::value; // true
//std::is_compound<std::string>::value; // true (⾮基础类型)
//// 3、类型关系检查
//std::is_same<int, int32_t>::value; // 取决于平台
//std::is_base_of<Base, Derived>::value;
//std::is_convertible<From, To>::value;
//// 4、类型修改
//std::add_const<int>::type; // const int
//std::add_pointer<int>::type; // int*
//std::add_lvalue_reference<int>::type; // int&
//std::remove_const<const int>::type; // int
//std::remove_pointer<int*>::type; // int
//std::remove_reference<int&>::type; // int
//// 4、条件类型选择
//std::conditional<true, int, float>::type; // int
//std::conditional<false, int, float>::type; // float
//// 5、类型推导
//// 函数的返回结果类型
//std::result_of<F(Args...)>::type; // C++17以后被废弃
//std::invoke_result<F, Args...>::type; // C++17以后使⽤这个
//template<class F, class... Args>
//using invoke_result_t = typename invoke_result<F, Args...>::type;
//


/*不同类型走对应不同类型逻辑处理*/

//#include<iostream>
////using namespace std;
//template<typename T>
//void process(T value) {
//	if constexpr (std::is_pointer_v<T>) {
//		// 指针类型的处理
//		std::cout << "Processing pointer: " << *value << std::endl;
//	} else if constexpr (std::is_integral_v<T>) {
//		// 整数类型的处理
//		std::cout << "Processing integer: " << value * 2 << std::endl;
//	} else if constexpr (std::is_floating_point_v<T>) {
//		// 浮点类型的处理
//		std::cout << "Processing float: " << value / 2.0 << std::endl;
//	} else{
//		// 默认处理
//		std::cout << "Processing unknown type" << std::endl;
//	}
//}


/*通过类型萃取进行不同平台套接字类型使用*/


//#if defined(_WIN32)
//#include<winsock2.h>
//using socket_t = SOCKET;
//#else
//using socket_t = int;
//#endif
//template<typename T>
//void close_handle(T handle) {
//	if constexpr (std::is_same_v<T, SOCKET>) {
//		closesocket(handle);
//	} else{
//		close(handle);
//	}
//}


/*模拟stl中迭代器使用的类型萃取*/

//namespace stl {
//	/*struct input_iterator_tag {};
//		struct output_iterator_tag {};
//		struct forward_iterator_tag : public input_iterator_tag {};
//		struct bidirectional_iterator_tag : public forward_iterator_tag {};
//		struct random_access_iterator_tag : public bidirectional_iterator_tag {};*/
//
//	template <class Iterator>
//	struct iterator_traits {
//		typedef typename Iterator::iterator_category iterator_category;
//		typedef typename Iterator::value_type value_type;
//		typedef typename Iterator::difference_type difference_type;
//		typedef typename Iterator::pointer pointer;
//		typedef typename Iterator::reference reference;
//	};
//
//	template < class T>
//	struct iterator_traits<T*> {
//		typedef std::random_access_iterator_tag iterator_category;
//		typedef T value_type;
//		typedef ptrdiff_t difference_type;
//		typedef T* pointer;
//		typedef T& reference;
//	};
//
//	template <class InputIterator>
//	inline typename iterator_traits<InputIterator>::difference_type
//		__distance(InputIterator first, InputIterator last,
//			std::input_iterator_tag) {
//		typename iterator_traits<InputIterator>::difference_type n = 0;
//		while (first != last) {
//			++first; ++n;
//		}
//		return n;
//	}
//
//	template <class RandomAccessIterator>
//	inline typename iterator_traits<RandomAccessIterator>::difference_type
//		__distance(RandomAccessIterator first, RandomAccessIterator last,
//			std::random_access_iterator_tag) {
//		return last - first;
//	}
//
//	template <class InputIterator>
//	inline typename iterator_traits<InputIterator>::difference_type
//		distance(InputIterator first, InputIterator last) {
//		using IterType = typename iterator_traits<InputIterator>::iterator_category;
//		return __distance(first, last, IterType());
//	}
//
//	template <class RandomAccessIterator>
//	inline typename iterator_traits<RandomAccessIterator>::difference_type
//		distance(RandomAccessIterator first, RandomAccessIterator last) {
//		using IterType = typename iterator_traits<RandomAccessIterator>::iterator_category;
//		return __distance(first, last, IterType());
//	}
//
//}
//
//template<class T>
//class vector
//{
//public:
//	typedef T* iterator;
//
//	// 类模板的成员函数，也可以是一个函数模板
//	template <class InputIterator>
//	vector(InputIterator first, InputIterator last)
//	{
//		// 为了提高效率可以提前resize
//		// 这里InputIterator是模板参数，随机迭代器支持减计算个数
//		// 单向和双向迭代器只是迭代计数计算个数
//		// reserve(last - first);
//
//		reserve(stl::distance(first, last));
//
//		while (first != last)
//		{
//			// push_back(*first);
//			++first;
//		}
//	}
//
//	void reserve(size_t n) {}
//private:
//	iterator _start = nullptr;
//	iterator _finish = nullptr;
//	iterator _end_of_storage = nullptr;
//};



/*SFINAE简单例子*/



//template<typename T>
//auto foo(T x) -> decltype(++x, void()) {
//	std::cout << "foo(T): " << x << " (can be incremented)\n";
//} 
//
//// C++17 使⽤void_t优化上⾯的写法
////template<typename T>
////auto foo(T x) -> std::void_t<decltype(++x)> {
//// std::cout << "foo(T): " << x << " (can be incremented)\n";
////}
//// 版本2：回退版本
//void foo(...) {
//	std::cout << "foo(...): fallback (cannot increment)\n";
//}
//
//int main() {
//	foo(42); // 调⽤版本1（int ⽀持 ++x）
//	foo(std::string("1111")); // 调⽤版本2（string 不⽀持 ++x）
//}





#include <type_traits>
#include <iostream>
// 对于整数类型启⽤此重载
template<typename T>
typename std::enable_if_t < std::is_integral_v<T>, T>
add_one(T t) {
	return t + 1;
} // 对于浮点类型启⽤此重载
template<typename T>
typename std::enable_if_t<std::is_floating_point_v<T>, T>
add_one(T t) {
	return t + 2.0;
} // 模板参数的检查
template<typename T,
	typename K = std::enable_if_t<std::is_integral_v<T>>>//这里的K也可以省略
void process_integer(T value) {
	// 只接受整数类型
} 
int main() {
	std::cout << add_one(5) << "\n"; // 调⽤整数版本，输出6
	std::cout << add_one(3.14) << "\n"; // 调⽤浮点版本，输出4.14
	// add_one("hello"); // 编译错误，没有匹配的重载
	process_integer(1);
	// process_integer(1.1); // 编译错误，没有匹配的重载
}



//int main() {
//
//
//
//
//
//}
